diff --git a/user_guide/changelog.html b/user_guide/changelog.html
index 477814d..461142f 100644
--- a/user_guide/changelog.html
+++ b/user_guide/changelog.html
@@ -69,6 +69,9 @@
 <li>Added support for naming custom library files in lower or uppercase.</li>
 <li>Fixed a bug in the active record class that was not resetting query data after a completed query.</li>
 <li>Fixed a bug that was supressing errors in controllers.</li>
+<li>Fixed a problem that can cause a loop to occur when the config file is missing.</li>
+<li>Fixed some bugs in the Oracle DB driver.</li>
+<li>Fixed some doc typos.</li>
 </ul>
 
 
diff --git a/user_guide/database/caching.html b/user_guide/database/caching.html
index 9a16a8f..615f74c 100644
--- a/user_guide/database/caching.html
+++ b/user_guide/database/caching.html
@@ -216,7 +216,7 @@
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
-Next Topic:&nbsp;&nbsp;<a href="export.html">Database Export Class</a>
+Next Topic:&nbsp;&nbsp;<a href="utilities.html">Database Utilities Class</a>
 <p>
 <p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://www.pmachine.com">pMachine, Inc.</a></p>
 </div>
diff --git a/user_guide/database/helpers.html b/user_guide/database/helpers.html
index 2b552f1..5ffe0c8 100644
--- a/user_guide/database/helpers.html
+++ b/user_guide/database/helpers.html
@@ -117,6 +117,8 @@
 <p>The first parameter is the table name, the second is an associative array with the data to be inserted.  The above example produces:</p>
 <code>INSERT INTO table_name (name, email, url) VALUES ('Rick', 'rick@your-site.com', 'www.your-site.com')</code>
 
+<p class="important">Note: Values are automatically escaped, producing safer queries.</p>
+
 
 
 <h2>$this->db->update_string(); </h2>
@@ -132,7 +134,7 @@
 <p>The first parameter is the table name, the second is an associative array with the data to be inserted, and the third parameter is the "where" clause. The above example produces:</p>
 <code> UPDATE exp_weblog SET name = 'Rick', email = 'rick@your-site.com', url = 'www.your-site.com' WHERE author_id = 1 AND status = 'active'</code>
 
-
+<p class="important">Note: Values are automatically escaped, producing safer queries.</p>
 
 
 </div>
diff --git a/user_guide/database/utilities.html b/user_guide/database/utilities.html
index a9227ab..3027b68 100644
--- a/user_guide/database/utilities.html
+++ b/user_guide/database/utilities.html
@@ -325,7 +325,7 @@
 
 <div id="footer">
 <p>
-Previous Topic:&nbsp;&nbsp;<a href="call_function.html">Custom Function Calls</a>
+Previous Topic:&nbsp;&nbsp;<a href="caching.html">DB Caching Class</a>
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
diff --git a/user_guide/general/caching.html b/user_guide/general/caching.html
index b4b3dab..f62c53d 100644
--- a/user_guide/general/caching.html
+++ b/user_guide/general/caching.html
@@ -94,7 +94,7 @@
 
 <h2>Deleting Caches</h2>
 
-<p>If you no longer wish to cache a file you can remove the caching tag and it will not longer be refreshed when it expires.  Note:
+<p>If you no longer wish to cache a file you can remove the caching tag and it will no longer be refreshed when it expires.  Note:
 Removing the tag will not delete the cache immediately.  It will have to expire normally.  If you need to remove it earlier you
 will need to manually delete it from your cache folder.</p>
 
diff --git a/user_guide/general/core_classes.html b/user_guide/general/core_classes.html
index f7e308a..92c35c7 100644
--- a/user_guide/general/core_classes.html
+++ b/user_guide/general/core_classes.html
@@ -144,6 +144,14 @@
 This allows you to substantially alter the Code Igniter core.</p>
 
 
+<h3>Setting Your Own Prefix</h3>
+
+<p>To set your own sub-class prefix, open your <dfn>application/config/config.php</dfn> file and look for this item:</p>
+
+<code>$config['subclass_prefix'] = 'MY_';</code>
+
+<p>Please note that all native Code Igniter libraries are prefixed with <kbd>CI_</kbd> so DO NOT use that as your prefix.</p>
+
 
 
 
diff --git a/user_guide/general/views.html b/user_guide/general/views.html
index 147667c..fa7f5eb 100644
--- a/user_guide/general/views.html
+++ b/user_guide/general/views.html
@@ -97,6 +97,7 @@
 
 <p>Where <var>name</var> is the name of your view file.  Note: The .php file extension does not need to be specified unless you use something other then <kbd>.php</kbd>.</p>
 
+
 <p>Now, open the controller file you made earlier called <dfn>blog.php</dfn>, and replace the echo statement with the view loading function:</p>
 
 
@@ -117,6 +118,13 @@
 
 <code>www.your-site.com/index.php/<var>blog</var>/</code>
 
+<h2>Storing Views within Sub-folders</h2>
+
+<p>Your view files can also be stored within sub-folders if you prefer that type of organization.  When doing so you will need
+to include the folder name loading the view.  Example:</p>
+
+<code>$this->load->view('<kbd>folder_name</kbd>/<var>file_name</var>');</code>
+
 
 <h2>Adding Dynamic Data to the View</h2>
 
diff --git a/user_guide/helpers/date_helper.html b/user_guide/helpers/date_helper.html
index 68e3068..0cf7884 100644
--- a/user_guide/helpers/date_helper.html
+++ b/user_guide/helpers/date_helper.html
@@ -315,7 +315,7 @@
 </tr><tr>
 <td class="td">UM1</td><td class="td">(UTC - 1:00) Azores, Cape Verde Islands</td>
 </tr><tr>
-<td class="td">(UTC</td><td class="td">(UTC) Casablanca, Dublin, Edinburgh, London, Lisbon, Monrovia</td>
+<td class="td">UTC</td><td class="td">(UTC) Casablanca, Dublin, Edinburgh, London, Lisbon, Monrovia</td>
 </tr><tr>
 <td class="td">UP1</td><td class="td">(UTC + 1:00) Berlin, Brussels, Copenhagen, Madrid, Paris, Rome</td>
 </tr><tr>
diff --git a/user_guide/helpers/smiley_helper.html b/user_guide/helpers/smiley_helper.html
index d818d00..36ea262 100644
--- a/user_guide/helpers/smiley_helper.html
+++ b/user_guide/helpers/smiley_helper.html
@@ -84,7 +84,7 @@
 
 <h2>Clickable Smileys Tutorial</h2>
 
-<p>Here is an example demonstrating how you might create a set of clickale smileys next to a form field. This example
+<p>Here is an example demonstrating how you might create a set of clickable smileys next to a form field. This example
 requires that you first download and install the smiley images, then create a controller and the View as described.</p>
 
 <p class="important"><strong>Important:</strong> Before you begin, please <a href="http://www.codeigniter.com/downloads/smileys.zip">download the smiley images</a> and put them in
diff --git a/user_guide/helpers/text_helper.html b/user_guide/helpers/text_helper.html
index f84acce..9cdada2 100644
--- a/user_guide/helpers/text_helper.html
+++ b/user_guide/helpers/text_helper.html
@@ -79,7 +79,7 @@
 <p>Truncates a string to the number of <strong>words</strong> specified.  Example:</p>
 
 <code>
-$str = "Here is a nice text string consisting of eleven words.";<br />
+$string = "Here is a nice text string consisting of eleven words.";<br />
 <br />
 $string = word_limiter($string, 4);<br /><br />
 
@@ -95,9 +95,9 @@
 of words so the character count may be slightly more or less then what you specify. Example:</p>
 
 <code>
-$str = "Here is a nice text string consisting of eleven words.";<br />
+$string = "Here is a nice text string consisting of eleven words.";<br />
 <br />
-$string = char_limiter($string, 20);<br /><br />
+$string = character_limiter($string, 20);<br /><br />
 
 // Returns:  Here is a nice text string&#8230;
 </code>
@@ -149,7 +149,7 @@
 you would like the phrase wrapped in.  Example:</p>
 
 <code>
-$str = "Here is a nice text string about nothing in particular.";<br />
+$string = "Here is a nice text string about nothing in particular.";<br />
 <br />
 $string = highlight_phrase($string, "nice text", '&lt;span style="color:#990000">', '&lt;/span>');
 </code>
diff --git a/user_guide/installation/downloads.html b/user_guide/installation/downloads.html
index 1f84a40..ca0e582 100644
--- a/user_guide/installation/downloads.html
+++ b/user_guide/installation/downloads.html
@@ -64,7 +64,7 @@
 
 <ul>
 <li><a href="http://www.codeigniter.com/download.php">Code Igniter V 1.5.0 (Current version)</a></li>
-<li><a href="http://www.codeigniter.com/CodeIgniter_1.4.0.zip">Code Igniter V 1.4.0</a></li>
+<li><a href="http://www.codeigniter.com/downloads/CodeIgniter_1.4.1.zip">Code Igniter V 1.4.1</a></li>
 <li><a href="http://www.codeigniter.com/downloads/CodeIgniter_1.3.3.zip">Code Igniter V 1.3.3</a></li>
 <li><a href="http://www.codeigniter.com/downloads/CodeIgniter_1.3.2.zip">Code Igniter V 1.3.2</a></li>
 <li><a href="http://www.codeigniter.com/downloads/CodeIgniter_1.3.1.zip">Code Igniter V 1.3.1</a></li>
diff --git a/user_guide/libraries/config.html b/user_guide/libraries/config.html
index d22881f..c88b5d6 100644
--- a/user_guide/libraries/config.html
+++ b/user_guide/libraries/config.html
@@ -179,7 +179,7 @@
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
-Next Topic:&nbsp;&nbsp;<a href="database/index.html">Database Class</a>
+Next Topic:&nbsp;&nbsp;<a href="../database/index.html">Database Class</a>
 <p>
 <p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://www.pmachine.com">pMachine, Inc.</a></p>
 </div>
diff --git a/user_guide/libraries/file_uploading.html b/user_guide/libraries/file_uploading.html
index 1fa93bf..25054c7 100644
--- a/user_guide/libraries/file_uploading.html
+++ b/user_guide/libraries/file_uploading.html
@@ -230,7 +230,7 @@
 $config['max_width']  = '1024';<br />
 $config['max_height']  = '768';<br />
 <br />
-$this->load->library('ftp', $config);<br /><br />
+$this->load->library('upload', $config);<br /><br />
 
 // Alternately you can set preferences by calling the initialize function.  Useful if you auto-load the class:<br />
 $this->upload->initialize($config);</code>
diff --git a/user_guide/libraries/ftp.html b/user_guide/libraries/ftp.html
index 0bec3a8..014b94d 100644
--- a/user_guide/libraries/ftp.html
+++ b/user_guide/libraries/ftp.html
@@ -63,8 +63,8 @@
 
 <h1>FTP Class</h1>
 
-<p>Code Igniter's FTP Class permits files to be uploaded, moved, renamed, and deleted on your server.  It also includes a "mirroring" function
-that permits a local directory to be recreated remotely via FTP.</p>
+<p>Code Igniter's FTP Class permits files to be transfered to a remote server. Remote files can also be moved, renamed,
+and deleted.  The FTP class also includes a "mirroring" function that permits an entire local directory to be recreated remotely via FTP.</p>
 
 <p class="important"><strong>Note:</strong>&nbsp; SFTP and SSL FTP protocols are not supported, only standard FTP.</p>
 
diff --git a/user_guide/libraries/sessions.html b/user_guide/libraries/sessions.html
index ed6260f..0179652 100644
--- a/user_guide/libraries/sessions.html
+++ b/user_guide/libraries/sessions.html
@@ -238,7 +238,7 @@
 
 </tr><tr>
 <td class="td"><strong>sess_encrypt_cookie</strong></td>
-<td class="td">TRUE</td>
+<td class="td">FALSE</td>
 <td class="td">TRUE/FALSE (boolean)</td>
 <td class="td">Whether to encrypt the session data.</td>
 
diff --git a/user_guide/libraries/unit_testing.html b/user_guide/libraries/unit_testing.html
index 692df00..0ebb401 100644
--- a/user_guide/libraries/unit_testing.html
+++ b/user_guide/libraries/unit_testing.html
@@ -155,7 +155,7 @@
 
 <p>To enable strict mode use this:</p>
 
-<code>$this->unit->strict(TRUE);</code>
+<code>$this->unit->use_strict(TRUE);</code>
 
 <h2>Enabling/Disabling Unit Testing</h2>
 
diff --git a/user_guide/libraries/xmlrpc.html b/user_guide/libraries/xmlrpc.html
index 9421e0f..01a88d7 100644
--- a/user_guide/libraries/xmlrpc.html
+++ b/user_guide/libraries/xmlrpc.html
@@ -485,7 +485,7 @@
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
-Next Topic:&nbsp;&nbsp;<a href="../helpers/array_helper.html">Array Helper</a>
+Next Topic:&nbsp;&nbsp;<a href="zip.html">Zip Encoding Class</a>
 <p>
 <p><a href="http://www.codeigniter.com">Code Igniter</a> &nbsp;&middot;&nbsp; Copyright &#169; 2006 &nbsp;&middot;&nbsp; <a href="http://www.pmachine.com">pMachine, Inc.</a></p>
 </div>
